package dao

import (
	"context"
	"fmt"
	"order_srv/basic/config"
	"order_srv/handler/models"
	"time"

	"gorm.io/gorm"
)

// CreateOrderContract 创建合同
func CreateOrderContract(ctx context.Context, contract *models.OrderContract) error {
	// 参数校验
	if contract.OrderID == 0 {
		return fmt.Errorf("订单ID不能为空")
	}
	if contract.ContractType == 0 {
		return fmt.Errorf("合同类型不能为空")
	}
	if contract.ContractContent == "" {
		return fmt.Errorf("合同内容不能为空")
	}

	// 生成合同编号
	contract.ContractNo = generateContractNo()

	err := config.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		// 1. 创建合同
		if err := tx.Create(contract).Error; err != nil {
			return fmt.Errorf("创建合同失败: %w", err)
		}

		// 2. 更新主订单的合同状态和URL
		if err := tx.Model(&models.Order{}).Where("id = ?", contract.OrderID).Updates(map[string]interface{}{
			"contract_status": 0, // 0-未签署 (对应合同的草稿状态)
			"contract_url":    "",
		}).Error; err != nil {
			return fmt.Errorf("更新主订单合同状态失败: %w", err)
		}

		// 3. 记录订单状态日志
		statusLog := &models.OrderStatusLog{
			OrderID:      contract.OrderID,
			FromStatus:   -1, // 初始状态
			ToStatus:     0,  // 草稿
			StatusType:   3,  // 3-合同状态
			OperatorID:   "system",
			OperatorType: 4, // 4-系统
			Reason:       "创建合同",
			Remark:       fmt.Sprintf("创建合同编号: %s", contract.ContractNo),
		}
		if err := tx.Create(statusLog).Error; err != nil {
			return fmt.Errorf("记录合同状态日志失败: %w", err)
		}
		return nil
	})

	if err != nil {
		return err
	}
	return nil
}

// SignContract 签署合同
func SignContract(ctx context.Context, contractID uint64, signerID string, signature string, signerType int8) error {
	// 参数校验
	if contractID == 0 {
		return fmt.Errorf("合同ID不能为空")
	}
	if signerID == "" {
		return fmt.Errorf("签署人ID不能为空")
	}
	if signature == "" {
		return fmt.Errorf("签名不能为空")
	}

	return config.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		// 1. 获取合同信息
		var contract models.OrderContract
		if err := tx.First(&contract, contractID).Error; err != nil {
			return err
		}

		// 2. 根据签署人类型更新相应的签署信息
		updates := map[string]interface{}{}
		if signerType == 1 { // 租客签署
			updates["tenant_signature"] = signature
			updates["tenant_signed_at"] = time.Now()
		} else if signerType == 2 { // 房东签署
			updates["landlord_signature"] = signature
			updates["landlord_signed_at"] = time.Now()
		} else {
			return fmt.Errorf("无效的签署人类型")
		}

		// 3. 更新合同签署信息
		if err := tx.Model(&models.OrderContract{}).Where("id = ?", contractID).Updates(updates).Error; err != nil {
			return err
		}

		// 4. 检查是否双方都已签署
		var updatedContract models.OrderContract
		if err := tx.First(&updatedContract, contractID).Error; err != nil {
			return err
		}

		// 如果双方都已签署，更新合同状态为已签署
		if updatedContract.TenantSignature != "" && updatedContract.LandlordSignature != "" {
			if err := tx.Model(&models.OrderContract{}).Where("id = ?", contractID).Updates(map[string]interface{}{
				"contract_status": 2, // 已签署
				"signed_at":      time.Now(),
			}).Error; err != nil {
				return err
			}

			// 更新主订单的合同状态
			if err := tx.Model(&models.Order{}).Where("id = ?", contract.OrderID).Updates(map[string]interface{}{
				"contract_status":  1, // 已签署
				"contract_url":    updatedContract.ContractURL,
				"contract_signed_at": time.Now(),
			}).Error; err != nil {
				return err
			}
		}

		// 5. 记录状态变更日志
		statusLog := &models.OrderStatusLog{
			OrderID:      contract.OrderID,
			FromStatus:   contract.ContractStatus,
			ToStatus:     updatedContract.ContractStatus,
			StatusType:   3, // 合同状态
			OperatorID:   signerID,
			OperatorType: signerType,
			Reason:       "合同签署",
			Remark:       fmt.Sprintf("签署人: %s, 签署类型: %d", signerID, signerType),
		}
		return tx.Create(statusLog).Error
	})
}

// 业务逻辑辅助函数

// generateContractNo 生成合同编号
func generateContractNo() string {
	return fmt.Sprintf("CON%d", time.Now().UnixNano())
}